/**
 * 数据过滤辅助类
 * 提供在Store计算属性中过滤数据的通用方法
 */
import dayjs from 'dayjs';

/**
 * 数据过滤辅助类
 */
export const dataFilterHelper = {
  /**
   * 按关键词过滤列表
   * @param {Array} list 数据列表
   * @param {String} keyword 关键词
   * @param {Array} fields 要搜索的字段列表
   * @returns {Array} 过滤后的列表
   */
  filterByKeyword(list, keyword, fields = ['title', 'content', 'description', 'name']) {
    if (!list || !list.length || !keyword) return list;
    
    const searchKey = keyword.toLowerCase().trim();
    if (!searchKey) return list;
    
    return list.filter(item => {
      // 任意一个字段包含关键词即匹配成功
      return fields.some(field => {
        if (!item[field]) return false;
        return String(item[field]).toLowerCase().includes(searchKey);
      });
    });
  },
  
  /**
   * 按状态过滤列表
   * @param {Array} list 数据列表
   * @param {Number|String|Array} status 状态值或状态数组
   * @param {String} statusField 状态字段名
   * @returns {Array} 过滤后的列表
   */
  filterByStatus(list, status, statusField = 'status') {
    if (!list || !list.length) return list;
    if (status === undefined || status === null || status === '') return list;
    
    // 处理数组形式的状态值
    if (Array.isArray(status)) {
      return list.filter(item => status.includes(item[statusField]));
    }
    
    // 处理单个状态值
    return list.filter(item => item[statusField] === status);
  },
  
  /**
   * 按日期范围过滤列表
   * @param {Array} list 数据列表
   * @param {Array} dateRange 日期范围 [startDate, endDate]
   * @param {String} dateField 日期字段名
   * @returns {Array} 过滤后的列表
   */
  filterByDateRange(list, dateRange, dateField = 'createTime') {
    if (!list || !list.length) return list;
    if (!dateRange || !Array.isArray(dateRange) || dateRange.length !== 2) return list;
    
    const [startDate, endDate] = dateRange;
    if (!startDate && !endDate) return list;
    
    return list.filter(item => {
      const itemDate = item[dateField];
      if (!itemDate) return false;
      
      const date = dayjs(itemDate);
      
      // 检查开始日期
      if (startDate && date.isBefore(dayjs(startDate), 'day')) {
        return false;
      }
      
      // 检查结束日期
      if (endDate && date.isAfter(dayjs(endDate), 'day')) {
        return false;
      }
      
      return true;
    });
  },
  
  /**
   * 按多个条件过滤列表
   * @param {Array} list 数据列表
   * @param {Object} conditions 过滤条件
   * @returns {Array} 过滤后的列表
   */
  filterByMultipleConditions(list, conditions) {
    if (!list || !list.length) return list;
    if (!conditions || Object.keys(conditions).length === 0) return list;
    
    return list.filter(item => {
      // 所有条件都匹配才返回true
      return Object.entries(conditions).every(([field, value]) => {
        // 跳过空值条件
        if (value === undefined || value === null || value === '') return true;
        
        // 处理数组值（多选）
        if (Array.isArray(value)) {
          if (value.length === 0) return true;
          return value.includes(item[field]);
        }
        
        // 处理日期范围
        if (field === 'dateRange' && Array.isArray(value) && value.length === 2) {
          const dateField = conditions.dateField || 'createTime';
          const [start, end] = value;
          
          if (start && end) {
            const itemDate = dayjs(item[dateField]);
            return itemDate.isAfter(dayjs(start), 'day') && 
                   itemDate.isBefore(dayjs(end), 'day');
          }
          
          return true;
        }
        
        // 处理关键词搜索
        if (field === 'keyword' || field === 'search') {
          const searchFields = conditions.searchFields || ['title', 'content', 'description', 'name'];
          const searchKey = String(value).toLowerCase().trim();
          
          if (!searchKey) return true;
          
          return searchFields.some(searchField => {
            if (!item[searchField]) return false;
            return String(item[searchField]).toLowerCase().includes(searchKey);
          });
        }
        
        // 默认精确匹配
        return item[field] === value;
      });
    });
  },
  
  /**
   * 对列表进行排序
   * @param {Array} list 数据列表
   * @param {String} field 排序字段
   * @param {String} order 排序方向('asc'或'desc')
   * @returns {Array} 排序后的列表
   */
  sortList(list, field = 'createTime', order = 'desc') {
    if (!list || !list.length) return list;
    if (!field) return list;
    
    const sortOrder = order.toLowerCase() === 'asc' ? 1 : -1;
    
    return [...list].sort((a, b) => {
      const valueA = a[field];
      const valueB = b[field];
      
      // 处理日期排序
      if (this.isDateField(field)) {
        const dateA = valueA ? dayjs(valueA).valueOf() : 0;
        const dateB = valueB ? dayjs(valueB).valueOf() : 0;
        return (dateA - dateB) * sortOrder;
      }
      
      // 处理数字排序
      if (typeof valueA === 'number' && typeof valueB === 'number') {
        return (valueA - valueB) * sortOrder;
      }
      
      // 处理字符串排序
      const strA = String(valueA || '').toLowerCase();
      const strB = String(valueB || '').toLowerCase();
      
      if (strA < strB) return -1 * sortOrder;
      if (strA > strB) return 1 * sortOrder;
      return 0;
    });
  },
  
  /**
   * 检查是否为日期字段
   * @param {String} field 字段名
   * @returns {Boolean} 是否为日期字段
   */
  isDateField(field) {
    const dateFields = [
      'createTime', 'CREATE_TIME', 'updateTime', 'UPDATE_TIME',
      'date', 'time', 'deadline', 'startTime', 'endTime',
      'createdAt', 'updatedAt', 'publishTime', 'birthday'
    ];
    
    return dateFields.some(dateField => 
      field.toLowerCase().includes(dateField.toLowerCase())
    );
  },
  
  /**
   * 按分页获取列表
   * @param {Array} list 完整列表
   * @param {Number} page 页码（从1开始）
   * @param {Number} pageSize 每页大小
   * @returns {Object} 分页结果 {list: Array, hasMore: Boolean, total: Number}
   */
  getPagedList(list, page = 1, pageSize = 20) {
    if (!list || !list.length) {
      return { list: [], hasMore: false, total: 0 };
    }
    
    const start = (page - 1) * pageSize;
    const end = start + pageSize;
    const pagedList = list.slice(start, end);
    
    return {
      list: pagedList,
      hasMore: end < list.length,
      total: list.length
    };
  },
  
  /**
   * 对象数组去重
   * @param {Array} array 对象数组
   * @param {String} key 唯一标识字段
   * @returns {Array} 去重后的数组
   */
  uniqueByKey(array, key = 'id') {
    if (!array || !array.length) return array;
    
    const seen = new Set();
    return array.filter(item => {
      const keyValue = item[key];
      if (seen.has(keyValue)) return false;
      seen.add(keyValue);
      return true;
    });
  },
  
  /**
   * 生成过滤器函数
   * @param {Object} filter 过滤条件
   * @returns {Function} 过滤函数
   */
  createFilterFunction(filter) {
    return (list) => {
      let result = [...list];
      
      // 按条件过滤
      if (filter) {
        result = this.filterByMultipleConditions(result, filter);
      }
      
      return result;
    };
  },
  
  /**
   * 生成排序函数
   * @param {Object} sort 排序配置 {field, order}
   * @returns {Function} 排序函数
   */
  createSortFunction(sort) {
    return (list) => {
      if (!sort || !sort.field) return list;
      return this.sortList(list, sort.field, sort.order);
    };
  },
  
  /**
   * 生成分页函数
   * @param {Object} pagination 分页配置 {page, size}
   * @returns {Function} 分页函数
   */
  createPaginationFunction(pagination) {
    return (list) => {
      if (!pagination) return { list, hasMore: false, total: list.length };
      return this.getPagedList(list, pagination.page, pagination.size);
    };
  }
}; 